We could use more context on the design decisions here. The old code failed with RBF (replace-by-fee) because it assumed the coinbase transaction at index 0, and sweep transaction is at index 1 in the block. And there's only one non-coinbase transaction in the block. The RBF sweep transactions invalidated this, or if multiple transactions are mined in the same block.

The new approach with resolveMinedTransferTxid finds which transaction in the block tapd know is a transfer. So decouples the tests from block transaction ordering, RBF replacements, multiple transactions in a block and tapd timing issues.

Moving the close after the SubscribeSendEvents fixes a race condition:

1. CloseChannel starts the close process
2. tapd processes close, fires SendStateComplete event
3. SubscribeSendEvents called — but event already fired
4. waitForSendEvent blocks forever waiting for missed event

By subscribing first, all events from the close operation are captured. This implements the standard "subscribe before action" pattern

So it's good we could use more comments IMO

This will get us more detailed failure messages about the state and make the testing more robust

Minor: 200 millis gets used in a few different spots, consider intorducing a constant

Minor: The fallthrough style is unusual. More idiomatic:

switch state {
case SendStateWaitTxConf, SendStateStorePostAnchorTxConf, SendStateTransferProofs:
    return true
default:
    return false
}

Or even simpler:

return state == SendStateWaitTxConf ||
    state == SendStateStorePostAnchorTxConf ||
    state == SendStateTransferProofs

Invariant: we can only add to postDeliveryRetryAttempts if AnchorTx is non-nil, and only need to delete it in the same case

This block imports the taproot output keys into lnd's wallet for outputs that belong to us. So the fix ensures addresses are always imported, regardless of who broadcasts.

It's a solid change. Think it would benefit from more comments.

Gives us a new context for importLocalAddresses which is idempotent and can be retried. As opposed to the CtxBlocking context (line 2189) for LogPendingParcel which is a critical write to disk that must complete even during shutdown.

Nit: The name suggests "permanent failure after max attempts". It actually tests non-recoverable state failure

Minor: Consider adding a test case for process shutdown similar to
`func TestSchedulePostDeliveryRetryShutdownDuringDelay(t *testing.T) {
porter := newTestChainPorter()
pkg := newTestSendPackage(SendStateTransferProofs)

recoverable := porter.schedulePostDeliveryRetry(
    pkg, SendStateTransferProofs, errors.New("failure"),
)
require.True(t, recoverable)

// Close quit before timer fires (base delay is 1 second)
close(porter.Quit)

// Verify goroutine exits cleanly, no re-queue
select {
case <-porter.outboundParcels:
    t.Fatalf("did not expect parcel after shutdown")
case <-time.After(1500 * time.Millisecond):
    // Success
}

}`